همان طور که مي بينيد، مقدار شيء ob1 درون i قرار نمي گيرد مگر اين که ابتدا cast انجام شود:

 

int i = (int)ob1;

اگر cast را حذف کنيد برنامه کامپايل نخواهد شد.

 

محدوديت هايي که در conversion operators وجود دارد:

 

Target-type يا source-type در conversion بايستي آموزش طراحی سایت  از جنس همان کلاسي باشد که conversion در آن تعريف شده است. براي مثال نمي توانيد تبديل double به int را از نو تعريف کنيد.

نمي توانيد class type را به نوع داده ي object تبديل کنيد.

نمي توانيد براي يک source-type و target-type هم تبديل implicit و هم تبديل explicit تعريف کنيد.

نمي توانيد از يک base class به يک derived class تبديل انجام دهيد (با مبحث ارث بري بعداً آشنا خواهيد شد).

نمي توانيد براي يک class-type به/از interface تبديل انجام دهيد (با مبحث interface بعداً آشنا خواهيد شد).

علاوه بر اين قوانين، براي انتخاب بين implicit يا explicit بايد دقت کنيد. implicit conversion بايد زماني مورد استفاده قرار گيرد که تبديل کاملاً عاري از خطا باشد. براي کسب اطمينان در اين مورد از اين دو قانون پيروي کنيد: يک، هيچ فقدان اطلاعاتي (مثل کوتاه سازي، سرريز، تغيير علامت و…) نبايد رخ دهد. دو، تبديل نبايد باعث بروز exception يا خطا در برنامه شود. اگر conversion نتواند اين دو قانون را رعايت کند، بايد از explicit conversion بهره ببريد.

 

هيچ نياز و اجباري نيست که عملکرد اپراتور overload شده با عمکرد اصلي آن operator ارتباط داشته باشد. با اين حال، به دليل اين که ساختار و خوانايي کد حفظ شود، بهتر است اپراتور overload شده بازتابي از رفتار اصلي آن operator باشد. براي مثال، + مربوط به کلاس TwoD از نظر مفهومي، مشابه + در نوع integer است و اينکه اين operator رفتاري مشابه / داشته باشد چندان جالب نيست.

 

توجه کنيد که الويت operator ها قابل تغيير نيست و نمي توانيد اين الويت را عوض کنيد همچنين تعدادي از operator ها قابل overload شدن نيستند. در جدول زير operator هايي که قابل overload شدن نيستند مشخص شده اند:

 

 

 

با operator هاي ناآشنا در جدول بالا، در مقالات آينده آشنا خواهيد شد. قابل ذکر است که operator هاي انتسابي نيز overload نمي شوند و همين طور operator هايي به شکل += نيز قابل overload شدن نيستند. البته اگر يک operator را overload کنيد که به طور کلي حالت ترکيبي مثل =+ را هم دارا باشد، اين حالت ترکيبي براي شيء شما نيز به صورت اتوماتيک اعمال مي شود. به عنوان مثال اگر + را overload کنيد، =+ نيز براي استفاده فعال است:

 

TwoD a = new TwoD(2, 2);

TwoD b = new TwoD(3, 4);

a += b;

نکته ي ديگر اين که، اگرچه نمي توانيد اپراتور [ ] که مربوط به index آرايه است را overload کنيد، اما مي توانيد از indexer استفاده کنيد که در ادامه به آن مي پردازيم.

 

Indexers

 

همان طور که مي دانيد، index گذاري آرايه از طريق اپراتور [ ] انجام مي شود. تعريف کردن اپراتور [ ] براي کلاس نيز امکان پذير است اما براي اين منظور از operator method استفاده نکرده و در عوض از Indexer استفاده مي کنيد. Indexer اجازه مي دهد يک شيء مانند يک آرايه index گذاري شود. Indexer ها مي توانند يک يا بيشتر از يک بعد داشته باشند و ما در اين جا با Indexer يک بعدي شروع مي کنيم.

 

فرم کلي Indexer يک بعدي به شکل زير است:

 

 

element-type this[int index] {

    // The get accessor

    get {

        // retu the value specified by index

    }

 

    // The set accessor

    set {

        // set the value specified by index

    }

}

در اين جا، element-type مشخص کننده ي نوع عنصر indexer است. از اين رو، هر عنصري که توسط indexer قابل دسترسي باشد، از نوع element-type است. اين نوع با نوع يک آرايه (که براي indexer در نظر مي گيريد و اصطلاحاْ به آن backing store مي گويند) يکسان است. پارامتر index در واقع index عنصري که مي خواهيد به آن دسترسي داشته باشيد را مشخص مي کند. توجه کنيد که نيازي نيست حتماْ جنس پارامتر int باشد اما از آن جا که indexer ها مشابه با index آرايه مورد استفاده قرار مي گيرند، استفاده از int در اين مورد رايج است.

 

درون بدنه ي indexer کلمه هاي get و set را مشاهده مي کنيد که به هر کدام از آن ها accessor گفته مي شود. يک accessor مشابه يک متد است با اين تفاوت که retu-type و parameter ندارد. هنگامي که از indexer استفاده مي کنيد اين accessor ها به طور اتوماتيک فراخواني مي شوند و هر دوي accessor ها index را به عنوان پارامتر دريافت مي کنند. اگر indexer در طرف چپ تساوي قرار گرفته باشد، بنابراين set accessor فراخواني و يک مقدار به عنصري که توسط index مشخص شده است، اختصاص داده مي شود. در غير اين صورت get accessor فراخواني شده و عنصر مشخص شده توسط index، retu مي شود. Set method همچنين يک پارامتر به اسم value دارد که شامل مقداري است که به يک index مشخص اختصاص داده مي شود.

 

يکي ديگر از مزيت هاي indexer اين است که مي توانيد دسترسي به آرايه را دقيقاً تحت کنترل داشته باشيد و از دسترسي هاي نامناسب جلوگيري کنيد.

 

به مثال ساده ي زير توجه کنيد:

using System;

class IndexerDemo

{

    int[] arr; // reference to underlying array (backing store)

    public int Lenght;

 

    public IndexerDemo(int size)

    {

        arr = new int[size];

        Lenght = size;

    }

 

    // Indexer

    public int this[int index]

    {

        // get accessor

        get

        {

            retu arr[index];

        }

 

        // set accessor

        set

        {

            arr[index] = value;

        }

    }

}

class idx

{

    static void Main()

    {

        IndexerDemo ob = new IndexerDemo(4);

 

        ob[0] = 10;

        ob[1] = 20;

        ob[2] = 30;

        ob[3] = 40;

 

        for (int i = 0; i < ob.Lenght; i++)

        {

            Console.WriteLine(ob[i]);

        }

    }

}

همان طور که مي بينيد، يک indexer تعريف کرده ايم که با عناصري از نوع int سروکار دارد. Indexer را به صورت public تعريف کرده ايم تا خارج از کلاس نيز قابل دسترس باشد. در قسمت get accessor مقدار [arr[index را retu کرده ايم و همين طور در قسمت set accessor نيز value به index عنصر مربوطه اختصاص داده مي شود. Value يک پارامتر بوده و شامل مقداري است که به آرايه اختصاص داده مي شود. نيازي نيست که يک indexer هم get و set را داشته باشد بلکه مي توانيد يک indexer داشته باشيد که تنها get يا set را دارد و read-only يا write-only است. البته در مثال بالا براي سادگي بيشتر، هيچ کنترلي روي مقاديري که قرار است get يا set شوند اعمال نکرده ايم.

 

در مثال زير روي get و set کنترل بيشتري اعمال کرده ايم:

using System;

class IndexerDemo

{

    int[] arr;

    public int Length;

    public bool ErrFlag;

    public IndexerDemo(int size)

    {

        arr = new int[size];

        Length = size;

    }

 

    public int this[int index]

    {

        get

        {

            if (Ok(index))

            {

                ErrFlag = false;

                retu arr[index];

            }

            else

            {

                ErrFlag = true;

                retu 0;

            }

        }

        set

        {

            if (Ok(index))

            {

                ErrFlag = false;

                arr[index] = value;

            }

            else

                ErrFlag = true;

        }

    }

 

    private bool Ok(int index)

    {

        if (index >= 0 && index < Length) 

            retu true;

        retu false;

    }

}

class Idx

{

    static void Main()

    {

        IndexerDemo ob = new IndexerDemo(5);

 

        for (int i = 0; i < 10; i++)

        {

            ob[i] = i * 10;

 

            if (ob.ErrFlag)

                Console.WriteLine("ob[{0}] is out of bound!", i);

            else

                Console.WriteLine("ob[{0}]: {1}", i, ob[i]);

        }

    }

}

خروجي:

 

همان طور که مي بينيد، پيش از آن که get يا set کنيم، ابتدا توسط متد ()Ok صحيح بودن index را بررسي کرده ايم تا در محدوده ي درست بوده و out of bound نباشد.البته براي خطايابي در مقالات آينده با روش مناسب تري آشنا خواهيد شد اما در حال حاضر همين روش مناسب است.

در اين مثال double indexer به نزديک ترين index گرد (round) مي شود:

 

using System;

class IndexerDemo

{

    int[] arr;

    public int Length;

    public bool ErrFlag;

    public IndexerDemo(int size)

    {

        arr = new int[size];

        Length = size;

    }

 

    public int this[int index]

    {

        get

        {

            if (Ok(index))

            {

                ErrFlag = false;

                retu arr[index];

            }

            else

            {

                ErrFlag = true;

                retu 0;

            }

        }

        set

        {

            if (Ok(index))

            {

                ErrFlag = false;

                arr[index] = value;

            }

            else

                ErrFlag = true;

        }

    }

 

    public int this[double index]

    {

        get

        {

            int idx = (int)Math.Round(index);

 

            if (Ok(idx))

            {

                ErrFlag = false;

                retu arr[idx];

            }

            else

            {

                ErrFlag = true;

                retu 0;

            }

        }

        set

        {

            int idx = (int)Math.Round(index);

            if (Ok(idx))

            {

                ErrFlag = false;

                arr[idx] = value;

            }

            else

            {

                ErrFlag = true;

            }

        }

    }

 

    private bool Ok(int index)

    {

        if (index >= 0 && index < Length) 

            retu true;

        retu false;

    }

}

class Idx

{

    static void Main()

    {

        IndexerDemo ob = new IndexerDemo(5);

 

        for (int i = 0; i < 10; i++)

        {

            ob[i] = i * 10;

 

            if (ob.ErrFlag)

                Console.WriteLine("ob[{0}] is out of bound!", i);

            else

                Console.WriteLine("ob[{0}]: {1}", i, ob[i]);

        }

 

        Console.WriteLine();

 

        ob[1] = 4;

        ob[2] = 8;

 

        Console.WriteLine("ob[1]: {0}", ob[1]);

        Console.WriteLine("ob[2]: {0}", ob[2]);

        Console.WriteLine("ob[1.3]: {0}", ob[1.3]);

        Console.WriteLine("ob[1.7]: {0}", ob[1.7]);

    }

}

خروجي:

 

 

 

همان طور که در خروجي مي بينيد، index هاي double توسط متد ()Math.Round به نزديک ترين عدد صحيح، گرد شده اند. ??? به ? و ??? به ? گرد شده است.

 

قابل ذکر است که نيازي نيست حتماً يک آرايه براي indexer داشته باشيد. مهم اين است که به يک کلاس اين قابليت را اضافه کنيد تا به شکل آرايه نيز بتوان از آن استفاده کرد.

 

به مثال زير توجه کنيد:

using System;

class IndexerDemo

{

    public int this[int index]

    {

        get

        {

            if (index >= 1 && index <= 10)

            {

                retu index * 10;

            }

            else retu -1;

        }

    }

}

class Idx

{

    static void Main()

    {

        IndexerDemo ob = new IndexerDemo();

 

        Console.WriteLine(ob[1]);

        Console.WriteLine(ob[2]);

        Console.WriteLine(ob[3]);

        Console.WriteLine(ob[11]);

        Console.WriteLine(ob[10]);

    }

}

همان طور که مي بينيد در مثال بالا از آرايه استفاده نکرده و مستقيماً حاصل ضرب index در ?? را retu کرده ايم و اگر index بين ? و ?? نباشد، ?- بازگشت داده مي شود. نکته ي ديگر اين است که تنها از get استفاده کرده ايم بدين معني که اين Indexer به صورت read-only است و در سمت راست يک تساوي مي تواند مورد استفاده قرار گيرد، نه در سمت چپ.

 

يعني استفاده به شکل زير، نادرست است:

 

1

ob[2] = 5;

اما به صورت زير، کاملاً صحيح است:

 

1

int i = ob[2];

دو محدوديت ديگر براي Indexer ها موجود است. يک، به دليل اين که indexer ها درواقع storage location (محل ذخيره سازي) تعريف نمي کنند و به نوعي متد هستند، استفاده از آن ها به عنوان پارامتر ref و out غيرمجاز است. دو، indexer نمي تواند به صورت static تعريف شود.

 

Indexer هاي چند بعدي

 

شما مي توانيد براي آرايه هاي چند بعدي نيز، indexer بسازيد.

 

به مثال زير توجه کنيد:

// A two-dimensional fail-soft array.

using System;

class FailSoftArray2D

{

    int[,] a; // reference to underlying 2D array

    int rows, cols; // dimensions

    public int Length; // Length is public

    public bool ErrFlag; // indicates outcome of last operation

 

    // Construct array given its dimensions.

    public FailSoftArray2D(int r, int c)

    {

        rows = r;

        cols = c;

        a = new int[rows, cols];

        Length = rows * cols;

    }

 

    // This is the indexer for FailSoftArray2D.

    public int this[int index1, int index2]

    {

        // This is the get accessor.

        get

        {

            if (ok(index1, index2))

            {

                ErrFlag = false;

                retu a[index1, index2];

            }

            else

            {

                ErrFlag = true;

                retu 0;

            }

        }

        // This is the set accessor.

        set

        {

            if (ok(index1, index2))

            {

                a[index1, index2] = value;

                ErrFlag = false;

            }

            else ErrFlag = true;

        }

    }

    // Retu true if indexes are within bounds.

    private bool ok(int index1, int index2)

    {

        if (index1 >= 0 & index1 < rows &

        index2 >= 0 & index2 < cols)

            retu true;

        retu false;

    }

}

// Demonstrate a 2D indexer.

class TwoDIndexerDemo

{

    static void Main()

    {

        FailSoftArray2D fs = new FailSoftArray2D(3, 5);

        int x;

 

        // Show quiet failures.

        Console.WriteLine("Fail quietly.");

        for (int i = 0; i < 6; i++)

            fs[i, i] = i * 10;

        for (int i = 0; i < 6; i++)

        {

            x = fs[i, i];

            if (x != -1) Console.Write(x + " ");

        }

        Console.WriteLine();

 

        // Now, display failures.

        Console.WriteLine("\nFail with error reports.");

        for (int i = 0; i < 6; i++)

        {

            fs[i, i] = i * 10;

            if (fs.ErrFlag)

                Console.WriteLine("fs[" + i + ", " + i + "] out-of-bounds");

        }

 

        Console.WriteLine();

        for (int i = 0; i < 6; i++)

        {

            x = fs[i, i];

            if (!fs.ErrFlag) Console.Write(x + " ");

            else

                Console.Write("\nfs[" + i + ", " + i + "] out-of-bounds");

        }

        Console.WriteLine();

    }

}